layui.define(['jquery', 'element', 'table'], function (exports) {
    "use strict";

    /**
     * 常用封装类
     * */
    var MOD_NAME = 'common',
        $ = layui.jquery,
        table = layui.table,
        element = layui.element;


    var common = new function () {

        /**
         * 获取当前表格选中字段
         * @param obj 表格回调参数
         * @param field 要获取的字段
         * */
        this.checkField = function (obj, field) {
            let data = table.checkStatus(obj.config.id).data;
            if (data.length === 0) {
                return "";
            }
            let ids = "";
            for (let i = 0; i < data.length; i++) {
                ids += data[i][field] + ",";
            }
            ids = ids.substring(0, ids.length - 1);
            return ids;
        }

        /**
         * 判断是否是一个json
         * @param str
         * @returns {boolean}
         */
        this.isJson = function (str) {
            try {
                if (typeof JSON.parse(str) == 'object') {
                    return true
                }
            } catch (e) {
                console.error("可能不是一个json", e)
            }
            return false
        }

        this.jsonRecursive = function (obj) {
            if (typeof obj !== 'object' && obj) {
                if (isStartAndEndWithBraces(obj, 'obj')) {
                    try {
                        obj = JSON.parse(obj)
                    } catch (e) {
                        console.warn(obj)
                        console.error(e)
                    }
                }

                if (isStartAndEndWithBraces(obj, 'arr')) {
                    try {
                        obj = JSON.parse(obj)
                    } catch (e) {
                        console.warn(obj)
                        console.error(e)
                    }
                }
                return obj;
            }
            let result
            if (obj) {
                result = Array.isArray(obj) ? [] : {};
            } else {
                result = ""
            }
            for (let key in obj) {
                if (obj.hasOwnProperty(key)) {
                    result[key] = this.jsonRecursive(obj[key]);
                }
            }
            return result;
        }


        /**
         * 当前是否为与移动端
         * */
        this.isModile = function () {
            return $(window).width() <= 768;
        }

        /**
         * 当前是否是手机端访问
         * @returns {boolean} true 是手机端访问
         */
        this.isModileReq = function () {
            const userAgent = navigator.userAgent;
            const mobileRegex = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i;
            return mobileRegex.test(userAgent)
        }

        /**
         * 获取当前窗口大小
         * 如果是mini、small 小屏幕 弹窗用百分比
         * @returns {{size: string, width: string, height: string}}
         */
        this.getWindowSize = function () {
            let width = $(window).width()
            // 大屏幕
            if (width > 1200) {
                return {size: "max", height: "90%", width: "600px"}
            }
            // 中等
            else if (width > 992) {
                return {size: "medium", height: "90%", width: "600px"}
            }
            // 小屏幕
            else if (width > 768) {
                return {size: "small", height: "80%", width: '80%'}
            }
            // 超小屏幕
            else {
                return {size: "mini", height: "90%", width: '80%'}
            }
        }

        /**
         * 16进制转grb
         * @param hex 16进制
         * @param a 透明度
         * @returns string 若传入了透明度 返回rgba 否则返回rgb
         */
        this.hexToRgb = function (hex, a) {
            if (!hex) {
                return ""
            }
            // 去除可能的井号 (#)
            hex = hex.replace("#", "");
            // 如果是三位的短格式，扩展为六位
            if (hex.length === 3) {
                hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
            }
            // 将每两位16进制转换为对应的十进制数
            const r = parseInt(hex.substring(0, 2), 16);
            const g = parseInt(hex.substring(2, 4), 16);
            const b = parseInt(hex.substring(4, 6), 16);
            if (a) {
                return `rgba(${r},${g},${b},${a})`
            }
            return `rgb(${r},${g},${b})`
        }

        /**
         * 获取当前服务域名
         * @returns {string}
         */
        this.getCurrentDomain = function () {
            return window.location.protocol + '//' + window.location.host
        }

        /**
         * 打开url
         * @param url
         */
        this.openUrlTarget = function (url) {
            const a = document.createElement('a');
            a.setAttribute('href', url)
            a.setAttribute('target', '_blank')
            a.setAttribute('id', 'd2admin-link-temp')
            document.body.appendChild(a)
            a.click()
            document.body.removeChild(document.getElementById('d2admin-link-temp'))
        }

        /**
         * json对象转url参数
         * @param json
         * @returns {string}
         */
        this.jsonToParam = function (json) {
            if (!json) return ''
            return Object.keys(json).map(key => {
                if (json[key] === undefined)
                    return ''
                return encodeURIComponent(key) +
                    '=' + encodeURIComponent(json[key])
            }).join('&')
        }

        /**
         * 获取数组对象中的指定的key
         * @param arr 数组对象
         * @param key 指定key
         * @returns {*[]} 指定key值集合
         */
        this.getKeyArr = function (arr, key) {
            let ids = [];
            for (let i = 0; i < arr.length; i++) {
                ids.push(arr[i][key])
            }
            return ids
        }

        this.pushArr = function (arr, val, num = 7) {
            if (arr.length < num) {
                arr.push(val)
            } else {
                arr.shift();
                arr.push(val)
            }
        }

        /**
         * 提交 json 数据
         * @param href        必选 提交接口
         * @param data        可选 提交数据
         * @param ajaxtype    可选 提交方式(默认为get)
         * @param table    可选 刷新父级表
         * @param callback    可选 自定义回调函数
         * @param dataType    可选 返回数据类型 智能猜测（可以是xml, json, script, 或 html）
         * @param is_async    可选 请求是否异步处理。默认是 true
         * @param is_cache    可选 浏览器是否缓存被请求页面。默认是 true
         * */
        this.submit = function (href, data, ajaxtype, table, callback, dataType, is_async, is_cache) {
            if (data !== undefined) {
                $.ajaxSetup({data: JSON.stringify(data)});
            } else {
                $.ajaxSetup({data: ''});
            }
            if (dataType !== undefined) {
                $.ajaxSetup({dataType: dataType});
            }
            if (is_async !== undefined) {
                $.ajaxSetup({async: is_async});
            }
            if (is_cache !== undefined) {
                $.ajaxSetup({cache: is_cache});
            }
            $.ajax({
                url: href,
                contentType: 'application/json',
                type: ajaxtype || 'get',
                success: callback != null ? callback : function (result) {
                    if (result.code === 1) {
                        layer.msg(result.msg, {icon: 1, time: 1000}, function () {
                            let frameIndex = parent.layer.getFrameIndex(window.name);
                            if (frameIndex) {
                                parent.layer.close(frameIndex);//关闭当前页
                            }
                            table && parent.layui.table.reload(table);
                        });
                    } else {
                        layer.msg(result.msg, {icon: 2, time: 1000});
                    }
                },
                error: function (xhr) {
                    if (xhr.status === 401) {
                        layer.msg('权限不足，您无法访问受限资源或数据', {icon: 5});
                        return;
                    }
                    if (xhr.status === 404) {
                        layer.msg('请求url地址错误，请确认后刷新重试', {icon: 5});
                        return;
                    }
                    if (xhr.status === 419) {
                        layer.msg('长时间未操作，自动刷新后重试！', {icon: 5});
                        setTimeout(function () {
                            window.location.reload();
                        }, 2000);
                        return;
                    }
                    if (xhr.status === 429) {
                        layer.msg('尝试次数太多，请一分钟后再试', {icon: 5});
                        return;
                    }
                    if (xhr.status === 500) {
                        layer.msg(xhr.responseJSON.message, {icon: 5});
                    }
                }
                , complete: function (xhr, status) {

                }
            })
        }

        /**
         * 下载文件
         * @param obj 文件对象
         * @param name 保存的文件名称
         * @param suffix 保存文件后缀
         */
        this.downloadFile = function (obj, name, suffix) {
            console.log(typeof obj)
            // 或者根据实际类型指定MIME类型
            let blob = new Blob([obj], {type: 'application/octet-stream'});
            const url = window.URL.createObjectURL(blob)
            const link = document.createElement('a')
            link.style.display = 'none'
            link.href = url
            const fileName = name + '-' + new Date().getTime() + '.' + suffix
            link.setAttribute('download', fileName)
            document.body.appendChild(link)
            link.click()
            document.body.removeChild(link)
        }

        this.arrToStr = function (arr = [], key) {
            if (arr.length === 0) {
                return ""
            }
            let str = ""
            for (let i = 0; i < arr.length; i++) {
                str += arr[i][key]
                if (i !== arr.length - 1) {
                    str += ","
                }
            }
            return str
        }

        /**
         * 计算字符串的hash
         * @param str
         * @returns {number}
         */
        this.hashCode = function (str) {
            var hash = 0;
            if (str.length === 0) return hash;
            for (var i = 0; i < str.length; i++) {
                var char = str.charCodeAt(i);
                hash = ((hash << 5) - hash) + char;
                hash = hash & hash; // Convert to 32bit integer
            }
            return hash;
        }

        /**
         * 修改数组对象中指定属性的值
         * @param arr 待修改的数组对象
         * @param conditionName 根据条件名
         * @param conditionVal 根据条件值
         * @param itemName 待属性名称
         * @param itemVal  修改后的值
         */
        this.setArrObjItem = function (arr, conditionName, conditionVal, itemName, itemVal) {
            for (let i = 0; i < arr.length; i++) {
                let item = arr[i]
                if (item[conditionName] === conditionVal) {
                    item[itemName] = itemVal
                }
            }
        }

        /**
         * 获取文件后缀
         * @param filename
         * @returns {*}
         */
        this.getStrExt = function (filename) {
            return filename.slice((filename.lastIndexOf(".") - 1 >>> 0) + 2);
        }

        /**
         * 实时将 输入在input的数据绑定到其他标签上
         * @param inputs input
         * @param callback 显示input值的元素
         */
        this.bindInputData = function (callback, ...inputs) {

            if (typeof callback !== 'function') {
                console.error("第一个参数必须为一个函数")
                return
            }
            inputs.forEach(input => {
                input.addEventListener('input', function () {
                    // name 属性
                    let name = this.getAttribute('name')
                    let res = {}
                    res[name] = this.value
                    callback(res)
                });
            })

        }

        // 处理数组相关


        // 处理字符串相关
        this.strFormart = function (template, ...args) {
            // 将模板字符串分割成部分，假设每个 {} 对应一个参数
            let parts = template.split('{}');
            // 如果args的长度大于模板中 {} 的数量，忽略多余的参数
            args = args.slice(0, parts.length - 1);
            // 使用reduce结合数组中的元素和args中的值生成最终的字符串
            return parts.reduce((result, part, index) => result + part + (args[index] || ''), '');
        }

        // 处理日期时间相关
        this.getDateStr = function () {
            // 创建一个Date对象
            const date = new Date();

            // 获取年、月、日、时、分、秒
            const year = date.getFullYear();
            const month = date.getMonth() + 1; // 月份从0开始，所以需要加1
            const day = date.getDate();
            const hours = date.getHours();
            const minutes = date.getMinutes();
            const seconds = date.getSeconds();
            let result = {}
            result.hm = `${fillZero(hours)}:${fillZero(minutes)}`
            result.ms = `${fillZero(minutes)}:${fillZero(seconds)}`
            result.shm = `${fillZero(hours)}:${fillZero(minutes)}:${fillZero(seconds)}`
            result.str = `${year}-${fillZero(month)}-${fillZero(day)} ${fillZero(hours)}:${fillZero(minutes)}:${fillZero(seconds)}`
            return result
        }
    }

    /**
     * 是否是 {} 符号开头和结尾
     * @param str
     * @returns {boolean}
     */
    function isStartAndEndWithBraces(str, target) {
        if (target === 'obj') {
            if (typeof str == 'string') {
                return str.startsWith('{') && str.endsWith('}');
            }
            return false
        } else {
            if (typeof str == 'string') {
                return str.startsWith('[') && str.endsWith(']');
            }
            return false
        }
    }

    /**
     * 数字小于0 前面补0
     * @param num
     * @returns {*|string}
     */
    function fillZero(num) {
        if (num < 10) {
            return '0' + num
        }
        return num
    }

    exports(MOD_NAME, common);
});
